package com.woniuxy.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.woniuxy.mapper.SysPermissionMapper;
import com.woniuxy.mapper.SysRolePermissionMapper;
import com.woniuxy.pojo.SysPermission;
import com.woniuxy.pojo.SysRole;
import com.woniuxy.pojo.SysRolePermission;
import com.woniuxy.pojo.dto.RolePermissionNode;
import com.woniuxy.service.SysRolePermissionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
* @author Administrator
* @description 针对表【t_sys_role_permission】的数据库操作Service实现
* @createDate 2025-06-07 14:24:25
*/
@Service
public class SysRolePermissionServiceImpl extends ServiceImpl<SysRolePermissionMapper, SysRolePermission>
    implements SysRolePermissionService {

    @Autowired
    SysPermissionMapper permissionMapper;

    @Autowired
    SysRolePermissionMapper rolePermissionMapper;

    @Override
    public List<RolePermissionNode> getPermissionTreeByRole(Integer roleId) {
        //1.获取全部的权限列表
        List<SysPermission> permissionList = permissionMapper.selectList(null);

        //1.1将全部的权限通过map封装便于查询
        Map<Integer, List<SysPermission>> permsMap = permissionList.stream()
                .collect(Collectors.groupingBy(p -> Optional.ofNullable(p.getParentId()).orElse(0)));

        //2.根据角色的id获取全部的角色权限

        List<SysRolePermission> rolePermsIds = rolePermissionMapper.selectList(new QueryWrapper<SysRolePermission>()
                                            .eq("role_id", roleId));

        //2.1 将rolePermsIds封装到无序集合中
        Set<Integer> rolePermsIdsSet = rolePermsIds.stream()
                .map(SysRolePermission::getPermissionId).collect(Collectors.toSet());


        //3.通过map和set构建权限树返回

        return buildTree(0,permsMap,rolePermsIdsSet);
    }

    //构建权限树
    /**
     * 递归构建角色权限树结构，并标记哪些节点被勾选（checked）
     *
     * @param parentId       当前遍历的父节点 ID（初始为 0L）
     * @param parentMap      以 parentId 为 key 的权限列表映射（用于构建多级树）
     * @param selectedIds    当前角色拥有的权限 ID 集合（即前端勾选的权限）
     * @return List<RolePermissionNode> 树形结构列表
     */
    private List<RolePermissionNode> buildTree(Integer parentId, Map<Integer,List<SysPermission>> parentMap,
                                               Set<Integer> selectedIds){

        //最终构建出的当前层级的权限节点列表
        List<RolePermissionNode> result = new ArrayList<>();

        //获取所有当前父节点的id 对应的子节点权限
        List<SysPermission> children = parentMap.getOrDefault(parentId,Collections.emptyList());

        //遍历每一个子权限，递归构建其子树
        for (SysPermission child : children) {
            RolePermissionNode node = new RolePermissionNode();

            //设置基础信息
            node.setId(child.getId().intValue());
            node.setPname(child.getPname());
            node.setParentId(child.getParentId() != null ? child.getParentId().intValue() : 0);

            //递归构建该节点的子树
            List<RolePermissionNode> childNodes = buildTree(child.getId(), parentMap, selectedIds);
            node.setChildren(childNodes);

            //节点标记逻辑
            //1.当前的节点是否选中该，=====》 在id集合中
            boolean checked = selectedIds.contains(child.getId());

            //2.判断子节点中是否有被选中的（如果有子节点被选中，父节点也要被选中）
            boolean anyChildChecked = childNodes.stream().anyMatch(RolePermissionNode::isChecked);

            //3.当前节点只要自己被选中，或子节点中有被选中的，就设置为true
            node.setChecked(checked || anyChildChecked);

            //添加当前构建的节点到返回结果中
            result.add(node);

        }
        return result;
    }

    @Transactional
    @Override
    public Boolean updateRolePermissions(Integer roleId, List<Integer> permissionIds) {
        //1.根据现在的roleId在数据库中查询出所有有的权限
        LambdaQueryWrapper<SysRolePermission> wrapper = Wrappers.lambdaQuery(SysRolePermission.class)
                            .eq(SysRolePermission::getRoleId, roleId);
        List<SysRolePermission> sysRolePermissions = rolePermissionMapper.selectList(wrapper);

        //2.根据现在的sysRolePermissions删除数据库中所有的权限
        if(sysRolePermissions != null && !sysRolePermissions.isEmpty()){
            //// 提取 id 列表
            List<Integer> ids = sysRolePermissions.stream()
                            .map(SysRolePermission::getId)
                            .collect(Collectors.toList());
            // // 批量删除
            rolePermissionMapper.deleteBatchIds(ids);
        }


        //3.添加现在的permissionIds
        Boolean b = this.saveBatch(permissionIds.stream().map(pid -> {
                    SysRolePermission permission = new SysRolePermission();
                    permission.setRoleId(roleId);
                    permission.setPermissionId(pid);
                    return permission;
                })
                .collect(Collectors.toList()));
        return b;
    }

    public List<SysRolePermission> getAllPermission(Integer id) {
        LambdaQueryWrapper<SysRolePermission> wrapper = Wrappers.lambdaQuery(SysRolePermission.class).eq(SysRolePermission::getRoleId, id);
        List<SysRolePermission> sysRolePermissions = rolePermissionMapper.selectList(wrapper);
        return sysRolePermissions;
    }
}




